home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / FireMan.swf / scripts / frame_1055 / PlaceObject2_276_1146 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Text File  |  2008-09-12  |  15KB  |  593 lines
  1. onClipEvent(enterFrame){
  2.    function hitPlatforms()
  3.    {
  4.       var u;
  5.       u = suelo = sueloI = sueloD = false;
  6.       i = -9;
  7.       while(i <= 0)
  8.       {
  9.          sueloI = sueloI || mapa.hitTest(_X + i,_Y,true);
  10.          i++;
  11.       }
  12.       i = 1;
  13.       while(i <= 9)
  14.       {
  15.          sueloD = sueloD || mapa.hitTest(_X + i,_Y,true);
  16.          i++;
  17.       }
  18.       if(sueloI && wallizq() && !sueloD && !techo)
  19.       {
  20.          return undefined;
  21.       }
  22.       if(sueloD && wallder() && !sueloI && !techo)
  23.       {
  24.          return undefined;
  25.       }
  26.       suelo = sueloI || sueloD;
  27.       if(suelo)
  28.       {
  29.          falling = false;
  30.          currenthigh = 0;
  31.          techo = false;
  32.          if(s)
  33.          {
  34.             landing.start();
  35.             s = false;
  36.          }
  37.          j = -15;
  38.          while(j <= 15)
  39.          {
  40.             i = -9;
  41.             while(i <= 9)
  42.             {
  43.                if(mapa.hitTest(_X + i,_Y + j,true) && !mapa.hitTest(_X + i,_Y + j - 1,true))
  44.                {
  45.                   u = true;
  46.                   break;
  47.                }
  48.                i++;
  49.             }
  50.             if(u)
  51.             {
  52.                break;
  53.             }
  54.             j++;
  55.          }
  56.          _Y = _Y + j;
  57.          j = vertical = 0;
  58.       }
  59.       return undefined;
  60.    }
  61.    function roof()
  62.    {
  63.       var u = techo = false;
  64.       i = -3;
  65.       while(i <= 3)
  66.       {
  67.          if(mapa.hitTest(_X + i,_Y - 30,true))
  68.          {
  69.             u = techo = true;
  70.             break;
  71.          }
  72.          i++;
  73.       }
  74.       return u;
  75.    }
  76.    function gridx(a)
  77.    {
  78.       return int(a / GRIDSIZE);
  79.    }
  80.    function gridy(b)
  81.    {
  82.       if(b >= 0)
  83.       {
  84.          return int(b / GRIDSIZE);
  85.       }
  86.       return Math.floor(b / GRIDSIZE);
  87.    }
  88.    function render()
  89.    {
  90.       if(!death)
  91.       {
  92.          scrollspeed = 0;
  93.          if(this.hitTest(_root.scrollmask))
  94.          {
  95.             doscroll = true;
  96.          }
  97.          if(_root.topeizq._x >= 0 && horizontal < 0 || _root.topeder._x <= 256 && horizontal > 0)
  98.          {
  99.             doscroll = false;
  100.          }
  101.          if(doscroll)
  102.          {
  103.             _X = lastX;
  104.             scrollspeed = setSpeed();
  105.          }
  106.          lastX = _X;
  107.          lastY = _Y;
  108.          if(timerdamage == 0 && hitted && !invisible)
  109.          {
  110.             timerdamage = FLASHTIME;
  111.             timerinvisible = INVISIBLETIME;
  112.             keys = false;
  113.             _root.currentdamage += DAMAGE;
  114.             barra.gotoAndStop(_root.currentdamage + 1);
  115.             _parent.fhitted.start();
  116.             if(rising || jumping)
  117.             {
  118.                vertical = 0.5;
  119.                falling = true;
  120.             }
  121.          }
  122.          if(timerdamage > 0)
  123.          {
  124.             flashing = true;
  125.             timerdamage--;
  126.             if(_xscale < 0 && !wallder())
  127.             {
  128.                if(doscroll)
  129.                {
  130.                   scrollspeed = hforce / 2;
  131.                }
  132.                else
  133.                {
  134.                   horizontal = hforce / 2;
  135.                }
  136.             }
  137.             if(_xscale > 0 && !wallizq())
  138.             {
  139.                if(doscroll)
  140.                {
  141.                   scrollspeed = hforce / 2 * -1;
  142.                }
  143.                else
  144.                {
  145.                   horizontal = hforce / 2 * -1;
  146.                }
  147.             }
  148.          }
  149.          if(flashing && timerdamage == 0)
  150.          {
  151.             flashing = false;
  152.             keys = true;
  153.             timerinvisible = INVISIBLETIME;
  154.             invisible = true;
  155.          }
  156.          if(invisible)
  157.          {
  158.             timerinvisible--;
  159.             timerinvisible % 2 != 0 ? (_visible = false) : (_visible = true);
  160.          }
  161.          if(timerinvisible <= 0 && invisible)
  162.          {
  163.             invisible = false;
  164.             hitted = false;
  165.             _visible = true;
  166.          }
  167.          if(_root.currentdamage + 1 >= MAXDAMAGE)
  168.          {
  169.             death = true;
  170.             barra.gotoAndStop(MAXDAMAGE);
  171.             _root.fdeath.start();
  172.          }
  173.          DAMAGE = 0;
  174.          if(!shooting && abletoshoot)
  175.          {
  176.             if(Key.isDown(SHOOT) && keys)
  177.             {
  178.                justshoot = true;
  179.                abletoshoot = false;
  180.             }
  181.             else
  182.             {
  183.                justshoot = false;
  184.             }
  185.          }
  186.          if(justshoot && !shooting)
  187.          {
  188.             if(_xscale > 0)
  189.             {
  190.                shoot1._x = _X + 41;
  191.             }
  192.             else
  193.             {
  194.                shoot1._x = _X - 41;
  195.             }
  196.             if(!vertical)
  197.             {
  198.                shoot1._y = _Y - 14;
  199.             }
  200.             else
  201.             {
  202.                shoot1._y = _Y - 20;
  203.             }
  204.             shoot1._visible = true;
  205.             if(_xscale > 0)
  206.             {
  207.                shoot1.dx = Math.abs(shoot1.dx);
  208.                shoot1._xscale = Math.abs(shoot1._xscale);
  209.             }
  210.             if(_xscale < 0)
  211.             {
  212.                shoot1.dx = Math.abs(shoot1.dx) * -1;
  213.                shoot1._xscale = Math.abs(shoot1._xscale) * -1;
  214.             }
  215.             blast.start();
  216.             shooting = true;
  217.             justshoot = false;
  218.          }
  219.          if(!shooting && !abletoshoot)
  220.          {
  221.             if(!Key.isDown(SHOOT))
  222.             {
  223.                abletoshoot = true;
  224.             }
  225.          }
  226.          x = setSpeed();
  227.          if(!flashing)
  228.          {
  229.             horizontal = x;
  230.          }
  231.          if(vertical == 0 && Key.isDown(ARRIBA) && upreleased && keys)
  232.          {
  233.             vertical = vforce * -1;
  234.             horizontal += platform.dx;
  235.             platformscroll = 0;
  236.             rising = true;
  237.             upreleased = false;
  238.             salto.start();
  239.          }
  240.          if(!falling && !uprelease)
  241.          {
  242.             if(!Key.isDown(ARRIBA))
  243.             {
  244.                upreleased = true;
  245.             }
  246.          }
  247.          if(rising)
  248.          {
  249.             if(roof())
  250.             {
  251.                falling = true;
  252.                startfall = true;
  253.                rising = false;
  254.             }
  255.             if(currenthigh < MAXJUMP && Key.isDown(ARRIBA) && !upreleased && !flashing)
  256.             {
  257.                if(roof())
  258.                {
  259.                   startfall = true;
  260.                   falling = true;
  261.                   rising = false;
  262.                }
  263.                if(currenthigh < vforcei)
  264.                {
  265.                   vertical = - Math.abs(vforcei);
  266.                }
  267.                else
  268.                {
  269.                   vertical = - Math.abs(vforce);
  270.                }
  271.                currenthigh += Math.abs(vertical);
  272.             }
  273.             else
  274.             {
  275.                vertical *= gravity;
  276.                currenthigh += Math.abs(vertical);
  277.                if(Math.abs(vertical) < 1)
  278.                {
  279.                   startfall = true;
  280.                   falling = true;
  281.                   rising = false;
  282.                }
  283.             }
  284.          }
  285.          if(Key.isDown(SLIDEKEY) && !rising && !falling && keys && slidereleased)
  286.          {
  287.             if(_xscale < 0 && !wallizq())
  288.             {
  289.                slideLeft = true;
  290.                slideRight = false;
  291.             }
  292.             if(_xscale > 0 && !wallder())
  293.             {
  294.                slideLeft = false;
  295.                slideRight = true;
  296.             }
  297.             slide = slideLeft || slideRight;
  298.             slidereleased = false;
  299.          }
  300.          if(slide && slidetimer == 0)
  301.          {
  302.             slidetimer = SLIDETIME;
  303.          }
  304.          if(slide && slidetimer > 0)
  305.          {
  306.             slidetimer--;
  307.             if(slidetimer == 0 || Key.isDown(IZQ) && slideRight || Key.isDown(DER) && slideLeft || falling || wallizq() && slideLeft || wallder() && slideRight)
  308.             {
  309.                slide = slideLeft = slideRight = slidetimer = 0;
  310.             }
  311.          }
  312.          if(!Key.isDown(SLIDEKEY) && !slidereleased)
  313.          {
  314.             slidereleased = true;
  315.          }
  316.          if(falling)
  317.          {
  318.             s = true;
  319.             if(startfall)
  320.             {
  321.                vertical = Math.abs(vforcei / 2) * accel;
  322.                startfall = false;
  323.             }
  324.             else
  325.             {
  326.                vertical = Math.abs(vertical) * accel;
  327.             }
  328.             if(vertical > MAXVERTICAL)
  329.             {
  330.                vertical = MAXVERTICAL;
  331.             }
  332.             platformscroll = 0;
  333.             hitPlatforms();
  334.             if(_Y >= 245)
  335.             {
  336.                death = true;
  337.                _root.fdeath.start();
  338.             }
  339.          }
  340.          if(tornado)
  341.          {
  342.             floating = true;
  343.             playtornado = true;
  344.             vertical2 += vforce;
  345.             if(vertical2 > MAXVERTICAL)
  346.             {
  347.                vertical2 = MAXVERTICAL / 6;
  348.             }
  349.          }
  350.          else
  351.          {
  352.             playtornado = false;
  353.          }
  354.          if(floating && !rising)
  355.          {
  356.             if(tornado)
  357.             {
  358.                vertical = - vertical2;
  359.             }
  360.             else
  361.             {
  362.                vertical = -4;
  363.                floating = false;
  364.                rising = true;
  365.                vertical2 = 0;
  366.             }
  367.          }
  368.          if(playtornado && !soundtrigged)
  369.          {
  370.             _root.wind04.setVolume(100);
  371.             _root.wind04.start();
  372.             u = 100;
  373.             soundtrigged = true;
  374.          }
  375.          if(soundtrigged && !playtornado && u > 0)
  376.          {
  377.             u -= 5;
  378.             _root.wind04.setVolume(u);
  379.             if(u == 0)
  380.             {
  381.                _root.wind04.stop();
  382.                playtornado = true;
  383.                soundtrigged = false;
  384.             }
  385.          }
  386.          tornado = false;
  387.          if(_root.windx)
  388.          {
  389.             horizontal += _root.windx;
  390.          }
  391.          _Y = _Y + vertical + platform.dy;
  392.          if(horizontal < 0 && !wallizq() || horizontal > 0 && !wallder())
  393.          {
  394.             _X = _X + horizontal;
  395.          }
  396.          drawframe();
  397.          doVscroll = false;
  398.          vscrollspeed = 0;
  399.          if(_Y <= 112 && rising || _Y >= 192 && falling)
  400.          {
  401.             doVscroll = true;
  402.          }
  403.          if(_root.topeabajo.hitTest(_root.scrollmask) && !rising)
  404.          {
  405.             doVscroll = false;
  406.          }
  407.          if(doVscroll)
  408.          {
  409.             _Y = lastY;
  410.             vscrollspeed = vertical;
  411.          }
  412.          x1 = LastX - platform._x;
  413.          x2 = _X - platform._x;
  414.          if(!falling && !rising)
  415.          {
  416.             hitPlatforms();
  417.             if(!suelo)
  418.             {
  419.                vertical = 2;
  420.                falling = true;
  421.             }
  422.          }
  423.       }
  424.       else
  425.       {
  426.          drawframe();
  427.          vertical = horizontal = doscroll = scrollspeed = 0;
  428.          if(!f)
  429.          {
  430.             _root.fade.begin = true;
  431.             f = true;
  432.          }
  433.       }
  434.    }
  435.    function wallizq()
  436.    {
  437.       var u = false;
  438.       var t = !slide ? 12 : 20;
  439.       i = -24;
  440.       while(i < -15)
  441.       {
  442.          if(mapa.hitTest(_X - t,_Y + i,true))
  443.          {
  444.             u = true;
  445.             break;
  446.          }
  447.          i++;
  448.       }
  449.       return u;
  450.    }
  451.    function wallder()
  452.    {
  453.       var u = false;
  454.       var t = !slide ? 12 : 20;
  455.       i = -24;
  456.       while(i < -15)
  457.       {
  458.          if(mapa.hitTest(_X + t,_Y + i,true))
  459.          {
  460.             u = true;
  461.             break;
  462.          }
  463.          i++;
  464.       }
  465.       return u;
  466.    }
  467.    function setSpeed()
  468.    {
  469.       if(slideLeft && !rising)
  470.       {
  471.          forward = true;
  472.          backward = false;
  473.          if(horizontal == 0)
  474.          {
  475.             return hforce * -1;
  476.          }
  477.          return hforce * -1.5;
  478.       }
  479.       if(slideRight && !rising)
  480.       {
  481.          forward = false;
  482.          backward = true;
  483.          if(horizontal == 0)
  484.          {
  485.             return hforce;
  486.          }
  487.          return hforce * 1.5;
  488.       }
  489.       if(Key.isDown(DER) && keys && !wallder())
  490.       {
  491.          forward = false;
  492.          backward = true;
  493.          if(horizontal == 0)
  494.          {
  495.             return hforcei;
  496.          }
  497.          return hforce;
  498.       }
  499.       if(Key.isDown(IZQ) && keys && !wallizq())
  500.       {
  501.          forward = true;
  502.          backward = false;
  503.          if(horizontal == 0)
  504.          {
  505.             return hforcei * -1;
  506.          }
  507.          return hforce * -1;
  508.       }
  509.       return 0;
  510.    }
  511.    function drawFrame()
  512.    {
  513.       if(victory)
  514.       {
  515.          this.gotoAndStop("victory");
  516.          return undefined;
  517.       }
  518.       if(death)
  519.       {
  520.          this.gotoAndStop("death");
  521.          return undefined;
  522.       }
  523.       if(flashing)
  524.       {
  525.          this.gotoAndStop("hitted");
  526.          return undefined;
  527.       }
  528.       if(lastX != _X)
  529.       {
  530.          !forward ? (_xscale = Math.abs(_xscale)) : (_xscale = Math.abs(_xscale) * -1);
  531.       }
  532.       if(!shooting)
  533.       {
  534.          if(lastY > _Y && rising)
  535.          {
  536.             this.gotoAndStop("jump");
  537.             _root.estado = 3;
  538.             return undefined;
  539.          }
  540.       }
  541.       else if(lastY > _Y && rising)
  542.       {
  543.          this.gotoAndStop("attackJ");
  544.          _root.estado = 4;
  545.          return undefined;
  546.       }
  547.       if(lastY < _Y && falling || floating)
  548.       {
  549.          this.gotoAndStop("fall");
  550.          _root.estado = 5;
  551.          return undefined;
  552.       }
  553.       if(slide)
  554.       {
  555.          this.gotoAndStop("slide");
  556.          _root.estado = 6;
  557.          return undefined;
  558.       }
  559.       if(shooting)
  560.       {
  561.          if(!horizontal)
  562.          {
  563.             this.gotoAndStop("attackST");
  564.             return undefined;
  565.          }
  566.          if(horizontal)
  567.          {
  568.             this.gotoAndStop("attackRU");
  569.             sprite.gotoAndPlay(frame);
  570.             _root.estado = 2;
  571.             return undefined;
  572.          }
  573.       }
  574.       else
  575.       {
  576.          if(!horizontal)
  577.          {
  578.             this.gotoAndStop("standing");
  579.             _root.estado = 0;
  580.             return undefined;
  581.          }
  582.          if(horizontal)
  583.          {
  584.             this.gotoAndStop("run");
  585.             _root.estado = 1;
  586.             return undefined;
  587.          }
  588.       }
  589.    }
  590.    render();
  591.    frame = sprite._currentframe;
  592. }
  593.